{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sleep() 和 wait() 的区别\n",
    "结合synchronized，会更好的理解sleep()和wait()这两个方法，当然也就知道了他们的区别了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sleep()\n",
    "sleep() 方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。\n",
    "**因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。**\n",
    "\n",
    "下面用一个例子来演示：\n",
    "\n",
    "Service类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Service {\n",
    "\n",
    "    public void mSleep(){\n",
    "        synchronized(this){\n",
    "            try{\n",
    "                System.out.println(\" Sleep 。当前时间：\"+System.currentTimeMillis());\n",
    "                Thread.sleep(3*1000);\n",
    "            }\n",
    "            catch(Exception e){\n",
    "                System.out.println(e);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public void mWait(){\n",
    "        synchronized(this){\n",
    "            System.out.println(\" Wait 。结束时间：\"+System.currentTimeMillis());\n",
    "\n",
    "        }\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就定义了两个方法， mSleep()方法会让调用线程休眠3秒，mWait() 就打印一句话。两个方法都使用了同步锁。\n",
    "\n",
    "SleepThread类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class SleepThread implements Runnable{\n",
    "\n",
    "    private Service service;\n",
    "\n",
    "    public SleepThread(Service service){\n",
    "        this.service = service;\n",
    "    }\n",
    "\n",
    "    public void run(){\n",
    "        service.mSleep();\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "线程类，用于调用Service 的mSleep方法\n",
    "\n",
    "WaitThread类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WaitThread implements Runnable{\n",
    "\n",
    "    private Service service;\n",
    "\n",
    "    public WaitThread(Service service){\n",
    "        this.service = service;\n",
    "    }\n",
    "\n",
    "    public void run(){\n",
    "        service.mWait();\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "线程类，用于调用Service 的mWait方法\n",
    "\n",
    "测试类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Test{\n",
    "    public static void main(){\n",
    "\n",
    "        Service mService = new Service();\n",
    "\n",
    "        Thread sleepThread = new Thread(new SleepThread(mService));\n",
    "        Thread waitThread = new Thread(new WaitThread(mService));\n",
    "        sleepThread.start();\n",
    "        waitThread.start();\n",
    "\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Sleep 。当前时间：1597738155934"
     ]
    }
   ],
   "source": [
    "Test.main();"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 梳理一下逻辑：\n",
    "\n",
    "首先sleepThread线程会启动起来，然后在run方法里调用Service对象的mSleep方法，到了同步代码块后，this就是Test类里创建的Service对象mService，sleepThread线程获得了Service对象的锁，之后进入了休眠状态，但并没有释放该Service对象的锁。\n",
    "这时waitThread线程也启动了起来，调用Service对象的mWait方法，同样到了同步代码块，因为Service对象的锁已经被sleepThread占了，所以waitThread线程只能干等着。\n",
    "等到sleepThread线程执行完毕（休眠结束）后释放了同步锁，waitThread线程拿到了同步锁，会继续执行，mWait才会被调用。\n",
    "\n",
    "如果sleepThread释放了机锁的话，waitThread 的任务会马上得到执行。从打印结果可以看出，waitThread 的任务是3秒钟之后才得到执行。\n",
    "\n",
    "同步锁，锁住的是一个对象。如果一个线程拿到了一个对象的机锁去执行一段同步代码块了，那么其他线程都不能执行这个对象的其他同步代码块。\n",
    "在这个例子中就是sleepThread线程拿到了service对象的同步锁，进入后休眠，但没有释放机锁，那么waitThread线程是不能执行这个service对象的其他同步代码块的，也就就是不能进入这一段代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test{\n",
    "    public void test(){\n",
    "        synchronized(this){\n",
    "            System.out.println(\" Wait 。结束时间：\"+System.currentTimeMillis());\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相信现在你已经理解了sleep方法没有释放机锁会带来什么结果了，那么继续wait"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## wait()\n",
    "**wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程。**\n",
    "\n",
    "下面修改程序如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Service {\n",
    "\n",
    "    public void mSleep(){\n",
    "        synchronized(this){\n",
    "\n",
    "            try{\n",
    "                Thread.sleep(3*1000);\n",
    "                this.notifyAll();\n",
    "                System.out.println(\" 唤醒等待 。 结束时间：\"+System.currentTimeMillis());\n",
    "            }\n",
    "            catch(Exception e){\n",
    "                System.out.println(e);\n",
    "            }\n",
    "\n",
    "        }\n",
    "\n",
    "    }\n",
    "\n",
    "    public void mWait(){\n",
    "\n",
    "        synchronized(this){\n",
    "            try{\n",
    "                System.out.println(\" 等待开始 。 当前时间：\"+System.currentTimeMillis());\n",
    "                this.wait();\n",
    "            }catch(Exception e){\n",
    "                System.out.println(e);\n",
    "            }\n",
    "        }\n",
    "\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Test{\n",
    "\n",
    "    public static void main(){\n",
    "\n",
    "        Service mService = new Service();\n",
    "\n",
    "        Thread sleepThread = new Thread(new SleepThread(mService));\n",
    "        Thread waitThread = new Thread(new WaitThread(mService));\n",
    "        waitThread.start();\n",
    "        sleepThread.start();\n",
    "\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 等待开始 。 当前时间：1597738940415\n"
     ]
    }
   ],
   "source": [
    "Test.main();"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样先看下打印结果\n",
    "![image.png](attachment:image.png)\n",
    "这里是先让 waitThread线程启动起来，然后waitThread线程进入等待状态，并释放了Service对象的锁，这时sleepThread也启动了，来到了mSleep方法的同步代码块，因为之前的waitThread线程已经释放了Service对象的机锁，sleepThread可以拿到对象锁，所以mSleep方法是会被马上调用的。然后sleepThread线程就是进入了睡眠状态，等到3秒休眠结束后调用notifyAll()唤醒了waitThread线程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### notify()，notifyAll() 的区别"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. wait()、notify/notifyAll() 方法是Object的本地final方法，无法被重写。\n",
    "\n",
    "\n",
    "2. wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。\n",
    "\n",
    "\n",
    "3. 由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。\n",
    "    - 当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。\n",
    "    - 只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。\n",
    "    - 也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程让其获得锁\n",
    "\n",
    "4. wait() 需要被try catch包围，以便发生异常中断也可以使wait等待的线程唤醒。\n",
    "\n",
    "\n",
    "5. notify 和wait 的顺序不能错，如果A线程先执行notify方法，B线程在执行wait方法，那么B线程是无法被唤醒的。\n",
    "\n",
    "\n",
    "6. notify 和 notifyAll的区别\n",
    "    - notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。\n",
    "    - notifyAll 会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒，推荐使用notifyAll 方法。比如在生产者-消费者里面的使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。\n",
    "    \n",
    "\n",
    "7. 在多线程中要测试某个条件的变化，使用if 还是while？\n",
    "    - 要注意，notify唤醒沉睡的线程后，线程会接着上次的执行继续往下执行。所以在进行条件判断时候，可以先把 wait 语句忽略不计来进行考虑；显然，要确保程序一定要执行，并且要保证程序直到满足一定的条件再执行，要使用while进行等待，直到满足条件才继续往下执行。如下代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class K {\n",
    "    //状态锁\n",
    "    private Object lock;\n",
    "    //条件变量\n",
    "    private int now,need;\n",
    "    public void produce(int num){\n",
    "        //同步\n",
    "        synchronized (lock){\n",
    "           //当前有的不满足需要，进行等待，直到满足条件\n",
    "            while(now < need){\n",
    "                try {\n",
    "                    //等待阻塞\n",
    "                    lock.wait();\n",
    "                } catch (InterruptedException e) {\n",
    "                    e.printStackTrace();\n",
    "                }\n",
    "                System.out.println(\"我被唤醒了！\");\n",
    "            }\n",
    "           // 做其他的事情\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "显然，只有当前值满足需要值的时候，线程才可以往下执行，所以，必须使用while 循环阻塞。注意，wait() 当被唤醒时候，只是让while循环继续往下走.如果此处用if的话，意味着if继续往下走，会跳出if语句块。"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 实现生产者和消费者问题 \n",
    "什么是生产者-消费者问题呢？\n",
    "![image.png](attachment:image.png)\n",
    "如上图，假设有一个公共的容量有限的池子，有两种人，一种是生产者，另一种是消费者。需要满足如下条件：\n",
    "\n",
    "1. 生产者产生资源往池子里添加，前提是池子没有满，如果池子满了，则生产者暂停生产，直到自己的生成能放下池子。\n",
    "2. 消费者消耗池子里的资源，前提是池子的资源不为空，否则消费者暂停消耗，进入等待直到池子里有资源数满足自己的需求。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### - 抽象仓库类 -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface AbstractStorage {\n",
    "    void consume(int num);\n",
    "    void produce(int num);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### - 仓库类 -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.LinkedList;\n",
    "\n",
    "/**\n",
    " *  生产者和消费者的问题\n",
    " *  wait、notify/notifyAll() 实现\n",
    " */\n",
    "public class Storage1 implements AbstractStorage {\n",
    "    //仓库最大容量\n",
    "    private final int MAX_SIZE = 100;\n",
    "    //仓库存储的载体\n",
    "    private LinkedList<Object> list = new LinkedList<Object>();\n",
    "\n",
    "    //生产产品\n",
    "    public void produce(int num){\n",
    "        //同步\n",
    "        synchronized (list){\n",
    "            //仓库剩余的容量不足以存放即将要生产的数量，暂停生产\n",
    "            while(list.size()+num > MAX_SIZE){\n",
    "                System.out.println(\"【要生产的产品数量】:\" + num + \"\\t【库存量】:\"\n",
    "                        + list.size() + \"\\t暂时不能执行生产任务!\");\n",
    "\n",
    "                try {\n",
    "                    //条件不满足，生产阻塞\n",
    "                    list.wait();\n",
    "                } catch (InterruptedException e) {\n",
    "                    e.printStackTrace();\n",
    "                }\n",
    "            }\n",
    "\n",
    "            for(int i=0;i<num;i++){\n",
    "                list.add(new Object());\n",
    "            }\n",
    "\n",
    "            System.out.println(\"【已经生产产品数】:\" + num + \"\\t【现仓储量为】:\" + list.size());\n",
    "\n",
    "            list.notifyAll();\n",
    "        }\n",
    "    }\n",
    "\n",
    "    //消费产品\n",
    "    public void consume(int num){\n",
    "        synchronized (list){\n",
    "\n",
    "            //不满足消费条件\n",
    "            while(num > list.size()){\n",
    "                System.out.println(\"【要消费的产品数量】:\" + num + \"\\t【库存量】:\"\n",
    "                        + list.size() + \"\\t暂时不能执行生产任务!\");\n",
    "\n",
    "                try {\n",
    "                    list.wait();\n",
    "                } catch (InterruptedException e) {\n",
    "                    e.printStackTrace();\n",
    "                }\n",
    "            }\n",
    "\n",
    "            //消费条件满足，开始消费\n",
    "            for(int i=0;i<num;i++){\n",
    "                list.remove();\n",
    "            }\n",
    "\n",
    "            System.out.println(\"【已经消费产品数】:\" + num + \"\\t【现仓储量为】:\" + list.size());\n",
    "\n",
    "            list.notifyAll();\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### -生产者 -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Producer extends Thread{\n",
    "    //每次生产的数量\n",
    "    private int num ;\n",
    "\n",
    "    //所属的仓库\n",
    "    public AbstractStorage abstractStorage;\n",
    "\n",
    "    public Producer(AbstractStorage abstractStorage){\n",
    "        this.abstractStorage = abstractStorage;\n",
    "    }\n",
    "\n",
    "    public void setNum(int num){\n",
    "        this.num = num;\n",
    "    }\n",
    "\n",
    "    // 线程run函数\n",
    "    @Override\n",
    "    public void run()\n",
    "    {\n",
    "        produce(num);\n",
    "    }\n",
    "\n",
    "    // 调用仓库Storage的生产函数\n",
    "    public void produce(int num)\n",
    "    {\n",
    "        abstractStorage.produce(num);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### - 消费者 -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Consumer extends Thread{\n",
    "    // 每次消费的产品数量\n",
    "    private int num;\n",
    "\n",
    "    // 所在放置的仓库\n",
    "    private AbstractStorage abstractStorage1;\n",
    "\n",
    "    // 构造函数，设置仓库\n",
    "    public Consumer(AbstractStorage abstractStorage1)\n",
    "    {\n",
    "        this.abstractStorage1 = abstractStorage1;\n",
    "    }\n",
    "\n",
    "    // 线程run函数\n",
    "    public void run()\n",
    "    {\n",
    "        consume(num);\n",
    "    }\n",
    "\n",
    "    // 调用仓库Storage的生产函数\n",
    "    public void consume(int num)\n",
    "    {\n",
    "        abstractStorage1.consume(num);\n",
    "    }\n",
    "\n",
    "    public void setNum(int num){\n",
    "        this.num = num;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### - 测试 -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Test{\n",
    "    public static void main() {\n",
    "        // 仓库对象\n",
    "        AbstractStorage abstractStorage = new Storage1();\n",
    "\n",
    "        // 生产者对象\n",
    "        Producer p1 = new Producer(abstractStorage);\n",
    "        Producer p2 = new Producer(abstractStorage);\n",
    "        Producer p3 = new Producer(abstractStorage);\n",
    "        Producer p4 = new Producer(abstractStorage);\n",
    "        Producer p5 = new Producer(abstractStorage);\n",
    "        Producer p6 = new Producer(abstractStorage);\n",
    "        Producer p7 = new Producer(abstractStorage);\n",
    "\n",
    "        // 消费者对象\n",
    "        Consumer c1 = new Consumer(abstractStorage);\n",
    "        Consumer c2 = new Consumer(abstractStorage);\n",
    "        Consumer c3 = new Consumer(abstractStorage);\n",
    "\n",
    "        // 设置生产者产品生产数量\n",
    "        p1.setNum(10);\n",
    "        p2.setNum(10);\n",
    "        p3.setNum(10);\n",
    "        p4.setNum(10);\n",
    "        p5.setNum(10);\n",
    "        p6.setNum(10);\n",
    "        p7.setNum(80);\n",
    "\n",
    "        // 设置消费者产品消费数量\n",
    "        c1.setNum(50);\n",
    "        c2.setNum(20);\n",
    "        c3.setNum(30);\n",
    "\n",
    "        // 线程开始执行\n",
    "        c1.start();\n",
    "        c2.start();\n",
    "        c3.start();\n",
    "\n",
    "        p1.start();\n",
    "        p2.start();\n",
    "        p3.start();\n",
    "        p4.start();\n",
    "        p5.start();\n",
    "        p6.start();\n",
    "        p7.start();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "【要消费的产品数量】:50\t【库存量】:0\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:20\t【库存量】:0\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:30\t【库存量】:0\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:10\t【现仓储量为】:10\n",
      "【要消费的产品数量】:50\t【库存量】:10\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:30\t【库存量】:10\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:20\t【库存量】:10\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:10\t【现仓储量为】:20\n",
      "【要消费的产品数量】:50\t【库存量】:20\t暂时不能执行生产任务!\n",
      "【已经消费产品数】:20\t【现仓储量为】:0\n",
      "【要消费的产品数量】:30\t【库存量】:0\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:50\t【库存量】:0\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:10\t【现仓储量为】:10\n",
      "【要消费的产品数量】:30\t【库存量】:10\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:50\t【库存量】:10\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:10\t【现仓储量为】:20\n",
      "【要消费的产品数量】:30\t【库存量】:20\t暂时不能执行生产任务!\n",
      "【要消费的产品数量】:50\t【库存量】:20\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:10\t【现仓储量为】:30\n",
      "【已经消费产品数】:30\t【现仓储量为】:0\n",
      "【要消费的产品数量】:50\t【库存量】:0\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:10\t【现仓储量为】:10\n",
      "【要消费的产品数量】:50\t【库存量】:10\t暂时不能执行生产任务!\n",
      "【已经生产产品数】:80\t【现仓储量为】:90\n"
     ]
    }
   ],
   "source": [
    "Test.main();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "sleep() 和 wait() 的区别就是 **调用sleep方法的线程不会释放对象锁，而调用wait() 方法会释放对象锁。**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "11.0.8+10-post-Ubuntu-0ubuntu120.04"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
